﻿using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using Sinacor.Infra.Common.Exceptions;
using Sinacor.Infra.Service.ExceptionHandling;
using System.Text.RegularExpressions;
using Sinacor.Infra.Service.Security;
using Sinacor.Servico.Bovespa.Ordens.BusinessEntity;
using Sinacor.Servico.Bovespa.Ordens.ResourceAccess;
using Sinacor.Servico.Bovespa.Cliente.BusinessEntity;
using Sinacor.Servico.Bovespa.Cliente.ResourceAccess;
using Sinacor.Infra.Service.Common;
using Sinacor.Infra.Service.Security.Authorization;

namespace Sinacor.Servico.Bovespa.Ordens.BusinessLogic
{
    public class Negocio : BaseBusinessLogic
    {

        #region Enums Auxiliares
        //20080424 11:25 - Adicionado para auxiliar na passagem do tipo de operacao sendo executado - DMilanez.7Comm
        private enum TipoOperacao
        {
            Inclusao,
            Alteracao
        }
        #endregion

        // <summary>
        /// Historico: ALT01
        /// Data : 10/01/2007
        /// Autor: Luciano Azevedo
        /// Obs.: CoorigidaS Business Exception
        #region Constantes de Erros
        private const int ERRO_NEGOCIO_HORANEGOCIONAOINFORMADA = 103074;
        private const int ERRO_NEGOCIO_CONTRAPARTEINVALIDA = 103075;
        private const int ERRO_NEGOCIO_BOLSANAOINFORMADA = 103076;
        private const int ERRO_NEGOCIO_NUMERONAOINFORMADO = 103077;
        private const int ERRO_NEGOCIO_DIGITONAOINFORMADO = 103078;
        private const int ERRO_NEGOCIO_NATUREZAOPERACAONAOINFORMADA = 103079;
        private const int ERRO_NEGOCIO_MERCADONAOINFORMADO = 103080;
        private const int ERRO_NEGOCIO_QUANTIDADEINVALIDA = 103081;
        private const int ERRO_NEGOCIO_PRECOINVALIDO = 103082;
        private const int ERRO_NEGOCIO_VENCIMENTOTERMO_NAOINFORMADO = 103083;
        private const int ERRO_NEGOCIO_ESTRATEGIAINVALIDA = 103084;
        private const int ERRO_NEGOCIO_PRAZOTERMO_NAOINFORMADO = 103085;
        private const int ERRO_NEGOCIO_TIPOTERMONAOINFORMADO = 103086;
        private const int ERRO_NEGOCIO_TIPOLIQUIDACAONAOINFORMADO = 103087;
        private const int ERRO_NEGOCIO_CORRESPONDENTEINVALIDO = 103088;
        private const int ERRO_NEGOCIO_DIASLIQUIDACAOINVALIDOS = 103089;
        private const int ERRO_NEGOCIO_DATAPREGAOINVALIDA = 103090;
        private const int ERRO_NEGOCIO_DATAPREGAONAOINFORMADA = 103171;
        private const int ERRO_NEGOCIO_QUANTIDADENAOINFORMADA = 103172;
        private const int ERRO_NEGOCIO_ESTRATEGIANAOINFORMADA = 103173;
        private const int ERRO_PESQUISA_SEM_RESULTADO = 103194; //Codigo corrigido - 20080305 - DMILANEZ
        private const int ERRO_NEGOCIO_CODIGOSISIN_DIVERGENTES = 103179;
        private const int ERRO_NEGOCIO_TITULO_OBJETO_NAO_CADASTRADO = 103180;
        private const int ERRO_NEGOCIO_TITULO_NAO_CADASTRADO = 103181;
        private const int ERRO_NEGOCIO_INFORMACOES_DIAS_UTEIS_FERIADOS_NAO_ENCONTRADAS = 103182;
        private const int ERRO_NEGOCIO_TITULONAOINFORMADO = 103183;
        private const int ERRO_NEGOCIO_FATORVALORIZACAOINVALIDO = 103184;
        private const int ERRO_NEGOCIO_VENCIMENTOOPCOESTERMOFUTURO_NAOINFORMADO = 103185;
        private const int ERRO_NEGOCIO_TIPOTERMOINVALIDO = 103186;
        private const int ERRO_NEGOCIO_ESPECIFICACAO_NAOINFORMADA = 103187;
        private const int ERRO_NEGOCIO_NOMESA_NAOINFORMADO = 103188;
        private const int ERRO_NEGOCIO_PERCENTUAL_CORRESPONDENTE_INVALIDO = 103189;
        private const int ERRO_NEGOCIO_TIPOOFERTABOVESPAFIX_NAOINFORMADO = 103190;
        private const int ERRO_NEGOCIO_TIPOOFERTABOVESPAFIX_INVALIDO = 103191;
        private const int ERRO_NEGOCIO_CORRESPONDENTE_NAOENCONTRADO = 103192;
        private const int ERRO_NEGOCIO_NAO_CADASTRADO = 103193;
        private const int ERRO_NEGOCIO_NAOINFORMADO = 103195;
        private const int ERRO_NEGOCIO_CHAVE_DUPLICADA = 103196;
        private const int ERRO_NEGOCIO_SEM_ORDEM = 109020;

		/// Data:12/05/2008 16:50
		/// Autor:CPimentel
		/// Obs: INCLUIDAS 3 NOVAS CONSTANTES DE ERRO - ISSUE #4701
        private const int ERRO_NEGOCIO_SEMPERMISSAO_INCLUIRNEGOCIO = 103207; //REF ISSUE ID0004701
        private const int ERRO_NEGOCIO_SEMPERMISSAO_ALTERARNEGOCIO = 103208; //REF ISSUE ID0004701
        private const int ERRO_NEGOCIO_SEMPERMISSAO_EXCLUIRNEGOCIO = 103209; //REF ISSUE ID0004701

		/// Data:12/05/2008 18:14
		/// Autor:CPimentel
		/// Obs: INCLUIDA NOVA CONSTANTE DE ERRO
        private const int ERRO_NEGOCIO_SEMPERMISSAO_CONSULTARNEGOCIO = 103210; //REF ISSUE ID0004700

        /// Data:12/05/2008
        /// Autor:RValadao
        /// Obs: INCLUIDA NOVAS CONSTANTES DE ERRO - REF ISSUE ID0004618
        private const int ERRO_NEGOCIO_CONTROLE_ORDENS_FECHADO = 103205; //REF ISSUE ID0004618
        private const int ERRO_NEGOCIO_FATURAMENTO_BOLSAS_FECHADO = 103206; //REF ISSUE ID0004618

        private const int ERRO_DATAPREGAOINVALIDA = 103022;
        #endregion

        /// Autor: Luciano Azevedo
        /// Data : ???
        /// Obs. : Criacao.
        /// 
        /// Data:06/02/2008 12:03
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// CORRECAO
        /// Metodo nao havia sido implementado
        /// 
        /// Data:07/02/2008 15:17
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Adicao do parametro modulo
        /// 
        /// Data:18/02/2008 16:41
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Alterado para passar a retornar um negocio
        public BusinessEntity.Negocio IncluirNegocio(BusinessEntity.Negocio request, BusinessEntity.Enum.ModuloChamador modulo)
        {
			/// Data:12/05/2008 16:58
			/// Autor:CPimentel
			/// Obs: INCLUIDA VERIFICACAO DE PERMISSAO - ISSUE #4701
            
			if (! Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("MNEG"))
				throw new BusinessException(ERRO_NEGOCIO_SEMPERMISSAO_INCLUIRNEGOCIO);

            /// Data:25/03/2008 11:40
            /// Autor:DMilanez.7Comm
            /// Obs: Alterado de forma a validar se o negocio foi informado
            if (request == null)
                throw new ValidationException(ERRO_NEGOCIO_NAOINFORMADO);

            ///realizar as validacoes basicas de entrada de dados
            ValidarEntradaInclusaoAlteracao(request);

            ResourceAccess.Negocio negocioDataAcess = new ResourceAccess.Negocio();

            //Já existe um negócio cadastrado com as informações Data de Pregão, Bolsa Movimento, Código de Negociação, Natureza Operação e Número do Negócio informados.
            ///checar se ja existe um negocio cadastrado com 
            ///NR_NEGOCIO,CD_NEGOCIO,CD_NATOPE,DT_PREGAO,CD_BOLSAMOV
            if (negocioDataAcess.VerificarExistenciaNegocio(request))
                throw new BusinessException(ERRO_NEGOCIO_CHAVE_DUPLICADA);

            ///atribuir os valores padroes da propriedades do negocio
            AtribuirValoresPadrao(request, true);

            ///realizar as validações de negócio 
            ValidarNegocioInclusaoAlteracao(request, modulo, TipoOperacao.Inclusao);

            negocioDataAcess.IncluirNegocio(request);

            ///se informou o correspondente
            if (request.Correspondente != null && request.Correspondente.Codigo > 0)
            {
                IncluirComitente(request);
            }

            if (request != null)
                request.Titulo.Descricao = request.NomeSA + " " + request.Especificacao;

            return request;
        }

        /// Autor: Luciano Azevedo
        /// Data : ???
        /// Obs. : Criacao.
        /// 
        /// Data:16/02/2008 17:02
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Correcoes diversas
        public BusinessEntity.Negocio AlterarNegocio(BusinessEntity.Negocio request, BusinessEntity.Enum.ModuloChamador modulo)
        {
			/// Data:12/05/2008 16:58
			/// Autor:CPimentel
			/// Obs: INCLUIDA VERIFICACAO DE PERMISSAO - ISSUE #4701
			if (!Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("MNEG"))
				throw new BusinessException(ERRO_NEGOCIO_SEMPERMISSAO_ALTERARNEGOCIO);

            /// Data:25/03/2008 11:40
            /// Autor:DMilanez.7Comm
            /// Obs: Alterado de forma a validar se o negocio foi informado
            if (request == null)
                throw new ValidationException(ERRO_NEGOCIO_NAOINFORMADO);

            bool dispararProcNegDig = false;
            bool dispararProcPorNegDig = false;
            
                BusinessEntity.Negocio negocioOriginal = new Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Negocio();
                try
                {
                ///realizar as validacoes basicas de entrada de dados
                ValidarEntradaInclusaoAlteracao(request);

                ///atribuir os valores padroes da propriedades do negocio
                AtribuirValoresPadrao(request, false);

                ///realizar as validações de negócio 
                ValidarNegocioInclusaoAlteracao(request, modulo, TipoOperacao.Alteracao);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            ResourceAccess.Negocio negocioRA = new ResourceAccess.Negocio();

            //recuperar negocio original      
            //NR_NEGOCIO, CD_NEGOCIO, CD_NATOPE, DT_PREGAO, CD_BOLSAMOV
            negocioOriginal.NumeroNegocio = request.NumeroNegocio;
            negocioOriginal.Titulo.Codigo = request.Titulo.Codigo;
            negocioOriginal.TipoNaturezaOperacao = request.TipoNaturezaOperacao;
            negocioOriginal.DataPregao = request.DataPregao;
            negocioOriginal.Bolsa = request.Bolsa;

            //recuperar o negocio pre-alteracao
            negocioOriginal = negocioRA.ConsultarNegocio(negocioOriginal);
            if (negocioOriginal == null)
                throw new BusinessException(ERRO_NEGOCIO_NAO_CADASTRADO);

            //20080412 18:02 - Alterado - DMilanez.7Comm
            if (!negocioOriginal.Correspondente.Codigo.HasValue)
                negocioOriginal.Correspondente.Codigo = 0;

            //20080419 17:14 - Alterado de forma a excutar o descasamento sempre que a quantida de for
            //alterada para atender ao chamado 3105 - DMilanez.7Comm
            if (negocioOriginal.TipoMercado != request.TipoMercado ||
                negocioOriginal.PrazoTermo != request.PrazoTermo ||
                negocioOriginal.Quantidade != request.Quantidade ||
                negocioOriginal.Preco != request.Preco ||
                negocioOriginal.ContraParte != request.ContraParte ||
                negocioOriginal.DiasLiquidacao != request.DiasLiquidacao ||
                VerificarEstrategiaPOPAlterada(request, negocioOriginal)
                )
            {
                request.QuantidadeCasada = 0;
                request.QuantidadeEspecificada = 0;
                request.TipoIndicadorOrigem = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoIndicadorOrigemNegocio.Digitacao;
                dispararProcPorNegDig = true;
            }

            if (negocioOriginal.TipoEstrategia != request.TipoEstrategia && !VerificarEstrategiaPOPAlterada(request, negocioOriginal))
            {
                dispararProcNegDig = true;
            }


            negocioRA.AlterarNegocio(request);

            //Codificado de acordo com a especificacao
            //Alteração:
            //   Atualizar tabela TORNEGD com alterações
            //   Se TORNEGD.CD_CORRESP antes de alteração do negócio <> 0
            //      (*) Remove Correspondente
            //   Se <Código do Correspondente> ( novo ) <> 0
            //      (*) Inserir Correspondente

            //se existe um correspondente no noegocio original
            if (negocioOriginal.Correspondente != null && negocioOriginal.Correspondente.Codigo > 0)
            {
                ExcluirComitente(negocioOriginal);
            }

            //20080423 09:37 - Alterado para atender ao chamado 3540 - DMilanez.7Comm
            //se informou o correspondente
            if (request.Correspondente != null && request.Correspondente.Codigo > 0)
            {
                IncluirComitente(request);
            }

            //20080423 09:37 - Alterado para atender ao chamado 3540 - DMilanez.7Comm
            if (negocioOriginal.Correspondente != null &&
                negocioOriginal.Correspondente.Codigo > 0)
            {
                if (negocioOriginal.Correspondente.Codigo != request.Correspondente.Codigo)
                {
                    negocioOriginal.DataPregao = request.DataPregao;
                    CalcularFinanceiroCorrespondente(negocioOriginal);
                }
            }


            //Se um dos seguintes atributos modificados:
            // -- Mercado
            // -- Prazo do Termo
            // -- Quantidade ( se diminuiu )
            // -- Preço
            // -- Contraparte
            // -- Dias para liquidação
            // -- Estratégia / Tipo de Oferta BovespaFix ( Se POP para outro ou vice-versa )
            // Descasar o negócio:
            //    Atualizar:
            //       TORNEGD.QT_CASADA       = 0
            //       TORNEGD.QT_ESPECIFICADA = 0
            //       TORNEGD.IN_ORINEG       = 'D'
            //    Disparar a procedure
            //       Se <Código do Correspondente> <> <Código do Correspondente> ( anterior à alteração )
            //          sInCorresp = 'S'
            //       Caso contrário
            //          sInCorresp = 'N'
            //       PR_NEGOCIOS.POR_NEGDIG( <Bolsa>, <Código de Negociação - Papel>, <Numero do Negócio>,
            //                               <Natureza de Operação>, <Data do Pregão dd/mm/yyyy>,
            //                               'M', sInCorresp, 'N' )
            // -- Estratégia / Tipo de Oferta BovespaFix ( demais modificações )
            //    Disparar a procedure
            //       PR_NEGOCIOS.NEGDIGE( <Bolsa>, <Código de Negociação - Papel>, <Numero do Negócio>,
            //                            <Natureza de Operação>, <Data do Pregão dd/mm/yyyy> )

            if (dispararProcPorNegDig)
            {
                string sInCorresp;
                if (request.Correspondente.Codigo != negocioOriginal.Correspondente.Codigo)
                    sInCorresp = "S";
                else
                    sInCorresp = "N";


                BusinessEntity.Resultado resultado =  negocioRA.ExecutarProcPorNegDig(request, "M", sInCorresp);

                if (!resultado.Sucesso)
                {
                    if (resultado.CodigoErro == -1)
                        throw new BusinessException(109405);
                    else
                        this.TratarExcecoes(resultado);
                }

                
            }

            if (dispararProcNegDig)
            {
                BusinessEntity.Resultado resultado = negocioRA.ExecutarProcNegDige(request);

                if (!resultado.Sucesso)
                {
                    if (resultado.CodigoErro == -1)
                        throw new BusinessException(109405);
                    else
                        this.TratarExcecoes(resultado);
                }
            }

            if (request != null)
                request.Titulo.Descricao = request.NomeSA + " " + request.Especificacao;

            return request;
        }
        /// <summary>
        /// Verificar se a estrategia foi alterada de ou para POP 
        /// 
        /// Data:16/02/2008 20:14
        /// Autor:DMilanez.7Comm
        /// Obs: Criacao do metodo
        /// </summary>
        /// <param name="negocioAlterado"></param>
        /// <param name="negocioOriginal"></param>
        /// <returns></returns>
        private bool VerificarEstrategiaPOPAlterada(BusinessEntity.Negocio negocioAlterado, BusinessEntity.Negocio negocioOriginal)
        {
            if (!negocioAlterado.TipoEstrategia.HasValue && !negocioOriginal.TipoEstrategia.HasValue)
            {
                return false;
            }
            else if (negocioOriginal.TipoEstrategia.HasValue && !negocioAlterado.TipoEstrategia.HasValue)
            {
                if (negocioOriginal.TipoEstrategia == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.POP)
                    return true;
                else
                    return false;
            }
            else if (!negocioOriginal.TipoEstrategia.HasValue && negocioAlterado.TipoEstrategia.HasValue)
            {
                if (negocioAlterado.TipoEstrategia == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.POP)
                    return true;
                else
                    return false;
            }
            else
            {
                if (negocioAlterado.TipoEstrategia != negocioOriginal.TipoEstrategia)
                {
                    if (negocioAlterado.TipoEstrategia == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.POP ||
                        negocioOriginal.TipoEstrategia == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.POP)
                        return true;
                    else
                        return false;
                }
                else
                    return false;
            }
        }

        /// <summary>
        /// Autor: Luciano Azevedo
        /// Data : ???
        /// Obs. : Criacao.
        /// 
        /// Autor: Eduardo Sertorio
        /// Data : 11/02/2008
        /// Obs. : Revisao e complemento do desenvolvimento.
        /// 
        /// Incluir parametro (BusinessEntity.Enum.ModuloChamador) - esertorio - 200805140027 - ref issue ID0004618
        /// </summary>
        /// <param name="negocio"></param>
        public void ExcluirNegocio(BusinessEntity.Negocio request, BusinessEntity.Enum.ModuloChamador modulo)
        {
            ValidarEstadoSistema(modulo); //incluir parametro (BusinessEntity.Enum.ModuloChamador) - esertorio - 200805140027 - ref issue ID0004618

			/// Data:12/05/2008 16:58
			/// Autor:CPimentel
			/// Obs: INCLUIDA VERIFICACAO DE PERMISSAO - ISSUE #4701
			if (!Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("MNEG"))
				throw new BusinessException(ERRO_NEGOCIO_SEMPERMISSAO_EXCLUIRNEGOCIO);

            /// Data:25/03/2008 11:40
            /// Autor:DMilanez.7Comm
            /// Obs: Alterado de forma a validar se o negocio foi informado
            if (request == null)
                throw new ValidationException(ERRO_NEGOCIO_NAOINFORMADO);

            ResourceAccess.Negocio negocioRA = new ResourceAccess.Negocio();
            string sInCorresp = "N";

            ValidarEntradaExclusao(request);

            //recuperar o negocio da base
            request = negocioRA.ConsultarNegocio(request);

            if (request == null)
                throw new BusinessException(ERRO_NEGOCIO_NAO_CADASTRADO);

            //20080413 12:48 - Alterado - DMilanez.7Comm
            if (request.Correspondente != null && request.Correspondente.Codigo > 0)
            {
                //Excluir comitente
                ExcluirComitente(request);

                sInCorresp = "S";

                //Disparar um cálculo financeiro para o correspondente/agente de compensação:
                CalcularFinanceiroCorrespondente(request); //20080325 - DMILANEZ - corrigido de forma a somente executar quando houver correspondente
            }
            else
            {
                sInCorresp = "N";
            }

            //executar Negocio Digitado - PR_NEGOCIOS.POR_NEGDIG
            negocioRA.ExecutarProcPorNegDig(request, sInCorresp);

            //excluir Negocio
            negocioRA.ExcluirNegocio(request);
        }

        /// <summary>
        /// Data:16/02/2008 19:49
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Metodo responsavel por realizar o calculo financeiro do correspondente
        /// </summary>
        /// <param name="request"></param>
        private void CalcularFinanceiroCorrespondente(BusinessEntity.Negocio request)
        {
            ResumoFinanceiro.BusinessEntity.ResumoFinanceiro beResumoFinanceiroRequest = new ResumoFinanceiro.BusinessEntity.ResumoFinanceiro();
            beResumoFinanceiroRequest.IsCorrespondente = true; //indicar uso do PR_CALFIN.FINANCEIRO_COR.
            beResumoFinanceiroRequest.DataMovimento = request.DataMovimento;
            beResumoFinanceiroRequest.CodigoCliente = request.Correspondente.Codigo.Value;
            new ResumoFinanceiro.ResourceAccess.ResumoFinanceiro().Calcular(beResumoFinanceiroRequest, "Sinacor.Servico.Bovespa.Ordens.Negocio");
        }

        /// <summary>
        /// Data:16/02/2008 19:20
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Criacao do metodo
        /// </summary>
        /// <param name="request"></param>
        private static void ExcluirComitente(BusinessEntity.Negocio request)
        {
            ResumoFinanceiro.BusinessEntity.Comitente beComitenteRequest = new ResumoFinanceiro.BusinessEntity.Comitente();
            beComitenteRequest.Negocio = new Ordens.BusinessEntity.Negocio();
            beComitenteRequest.Negocio.NumeroNegocio = request.NumeroNegocio.Value;
            beComitenteRequest.Titulo = request.Titulo.Codigo;
            beComitenteRequest.Negocio.TipoNaturezaOperacao = request.TipoNaturezaOperacao.Value;
            beComitenteRequest.Negocio.Bolsa = request.Bolsa;
            beComitenteRequest.Negocio.DataPregao = request.DataPregao.Value;
            beComitenteRequest.CodigoCliente = request.Correspondente.Codigo.Value;
            (new ResumoFinanceiro.ResourceAccess.Comitente()).ExcluirComitente(beComitenteRequest);
        }

        /// Autor: Luciano Azevedo
        /// Data : ???
        /// Obs. : Criacao.
        /// 
        /// Data:06/02/2008 13:43
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Alterada forma de chamar o metodo CarregarFatorLiquidacao
        private void AtribuirValoresPadrao(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Negocio negocio, bool isInclusao)
        {
            Titulo.ResourceAccess.Titulo tituloRA = new Sinacor.Servico.Bovespa.Titulo.ResourceAccess.Titulo();

            if (negocio.Bolsa == "1" && !negocio.DigitoNegocio.HasValue)
                negocio.DigitoNegocio = 0;

            if ((negocio.Bolsa == "1" || negocio.Bolsa == "5" || negocio.Bolsa == "8") && !negocio.TipoLiquidacaoNegocio.HasValue)
                negocio.TipoLiquidacaoNegocio = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacaoNegocio.LiquidacaoPeloLiquido;

            negocio.Titulo.DataPregao = negocio.DataPregao;
                       
            switch (negocio.TipoMercado.Value)
            {
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.BOX:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.BOX;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.CotasETF:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.CotasETF;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Estruturado:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.Estruturado;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoCompra:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoCompra;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoVenda:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoVenda;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Fracionario:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.Fracionario;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Futuro:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.Futuro;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.IntegralizacaoResgateCotas:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.IntegralizacaoResgateCotas;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Leilao:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.Leilao;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.LeilaoNaoCotados:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.LeilaoNaoCotados;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.OpcaoCompra;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.OpcaoVenda;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVendaCompra:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.OpcaoVendaCompra;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Termo:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.Termo;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.VencimentoFuturo:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.VencimentoFuturo;
                    break;
                case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista:
                    negocio.Titulo.TipoMercado = Titulo.BusinessEntity.Enum.TipoMercado.Vista;
                    break;
            }

            negocio.Titulo = tituloRA.ConsultarTituloCodigoMercadoDataPregao(negocio.Titulo, true);

            //movido - ini bloco - esertorio - 200805301704 - ref issue ID0005169
            //esta verificacao deve ser feita antes de re-atribuir a data do pregao ao titulo - esertorio - 200805301704 - ref issue ID0005169
            if (negocio.Titulo == null)
                throw new BusinessException(ERRO_NEGOCIO_TITULO_NAO_CADASTRADO);
            //movido - fim bloco - esertorio - 200805301704 - ref issue ID0005169

            negocio.Titulo.DataPregao = negocio.DataPregao;//20080426 15:06 - Alterado para atender ao chamado 3349 - DMilanez.7Comm

            if (string.IsNullOrEmpty(negocio.Especificacao))
            {
                negocio.Especificacao = negocio.Titulo.Especificacao;
                if (string.IsNullOrEmpty(negocio.Especificacao))
                    throw new BusinessException(ERRO_NEGOCIO_ESPECIFICACAO_NAOINFORMADA);
            }

            if (string.IsNullOrEmpty(negocio.NomeSA))
            {
                negocio.NomeSA = negocio.Titulo.NomeSA;
                if (string.IsNullOrEmpty(negocio.NomeSA))
                    throw new BusinessException(ERRO_NEGOCIO_NOMESA_NAOINFORMADO);
            }

            /// Data:12/02/2008 15:13
            /// Autor:DMilanez.7Comm
            /// Obs:
            /// alterada forma de chamar os metodos, uma vez que passaram a ter retorno void
            CarregarFatorLiquidacao(negocio);
            CarregarDiasLiquidacao(negocio);///07/02/2008 - DMilanez - alterada forma de chamar metodo 
            CarregarTituloObjeto(negocio);///07/02/2008 - DMilanez - alterada forma de chamar metodo 
            CarregarCasamento(negocio);

            ///atribuir valores default para inclusao de negocio
            negocio.QuantidadeEspecificada = 0;
            negocio.TipoIndicadorOrigem = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoIndicadorOrigemNegocio.Digitacao;

            //20080413 15:39 - Alterado - DMilanez.7Comm
            if (isInclusao)
                negocio.PontaGeradoraOferta = false;

            negocio.QuantidadeCasada = 0;
            negocio.CodigoCliente = 0;

            negocio.DataMovimento = (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.DataMovimento()).RecuperarDataMovimento();

            ///caso n tenha informado a hora do negocio, recuperar a hora da base de dados
            if (!negocio.HoraNegocio.HasValue)
                negocio.HoraNegocio = (new Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro()).RecuperarDataSistemaBancoDados();

            //20080419 17:57 - Alterado de forma a assumir a origem mega caso n seja informado - DMilanez.7Comm
            if (!negocio.TipoOrigem.HasValue)
                negocio.TipoOrigem = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrigemNegocio.MegaBolsa;
        }

        /// Autor: Luciano Azevedo
        /// Data : ???
        /// Obs. : Criacao.
        /// 
        /// Data:08/02/2008 10:51
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Parametros de entrada foram subtituidos por uma BE
        /// 
        /// Data:12/02/2008 15:15
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Retorno passou a ser void
        private void CarregarCasamento(BusinessEntity.Negocio request)
        {
            if (request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Termo)
            {
                if (request.VencimentoOpcoesTermo.HasValue)
                    request.CodigoCasamento = request.Titulo.CodigoISIN + request.VencimentoOpcoesTermo.Value.ToShortDateString();
                else
                    request.CodigoCasamento = request.Titulo.CodigoISIN + request.PrazoTermo.ToString();
            }
            else if (request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra ||
                      request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda ||
                      request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.VencimentoFuturo ||
                      request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Futuro)
                request.CodigoCasamento = request.Titulo.CodigoISIN + request.Titulo.Codigo;
            else
                request.CodigoCasamento = request.Titulo.CodigoISIN;
        }

        /// Autor: Luciano Azevedo
        /// Data : ???
        /// Obs. : Criacao.
        /// 
        /// Data:06/02/2008 13:43
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// CORRECAO
        /// Alterado para receber um be como parametro
        /// 
        /// Data:12/02/2008 15:13
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Retorno passou a ser void
        private void CarregarFatorLiquidacao(BusinessEntity.Negocio request)
        {
            ResourceAccess.Negocio negocioRA = new ResourceAccess.Negocio();

            if (request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Termo ||
                request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Futuro)
                request.NaoLiquidaNota = true;
            if (request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista &&
                request.Titulo.CodigoISIN.Substring(6, 2) == "PP")
                request.NaoLiquidaNota = true;

            if (!request.NaoLiquidaNota)
                request.NaoLiquidaNota = negocioRA.ConsultarFatorLiquidacao(request);//(request.TipoMercado, request.TipoNaturezaOperacao);
        }

        /// Autor: Luciano Azevedo
        /// Data : ???
        /// Obs. : Criacao.
        /// 
        /// Data:07/02/2008 15:19
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Parametros de entrado subtituidos por uma entidade de negocio
        /// 
        /// Data:12/02/2008 15:13
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Retorno passou a ser void
        private void CarregarDiasLiquidacao(BusinessEntity.Negocio request)
        {
            if (!request.DiasLiquidacao.HasValue || request.DiasLiquidacao.Value < 0)
            {
                if (request.TipoLiquidacaoNegocio == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacaoNegocio.LiquidacaoPeloBruto)
                    request.DiasLiquidacao = 0;
                else if (request.Bolsa == "3" || request.Bolsa == "7")
                    request.DiasLiquidacao = 1;
                else
                    request.DiasLiquidacao = request.Titulo.NumeroDiasLiquidacao;//20080403 18:08 - Alterado - DMilanez.7Comm
            }
        }

        /// <summary>
        /// Autor: Luciano Azevedo
        /// Data : ???
        /// Obs. : Criacao.
        /// 
        /// Metodo responsavel por consultar a lista de Negocios
        /// </summary>
        /// <param name="negocio"></param>
        /// <returns>colecao de negocios</returns>
        public List<BusinessEntity.Negocio> ConsultarNegocios(BusinessEntity.Negocio negocio)
        {

            ResourceAccess.Negocio negocioRA = new ResourceAccess.Negocio();
            List<BusinessEntity.Negocio> lstNegocios = negocioRA.ConsultarNegocios(negocio);

            if (lstNegocios != null && lstNegocios.Count > 0)
                return lstNegocios;
            else
                return new List<BusinessEntity.Negocio>();
        }

		public List<BusinessEntity.Negocio> ConsultarGridNegocios(BusinessEntity.Negocio negocio)
		{
			/// Data:12/05/2008 18:13
			/// Autor:CPimentel
			/// Obs: INCLUIDA NOVA FUNCAO DE CONSULTA DE NEGOCIOS SEM VERIFICACAO DE PERMISSAO DE ACESSO
			ResourceAccess.Negocio negocioRA = new ResourceAccess.Negocio();
			List<BusinessEntity.Negocio> lstNegocios = negocioRA.ConsultarNegocios(negocio);

			if (lstNegocios != null && lstNegocios.Count > 0)
				return lstNegocios;
			else
				return new List<BusinessEntity.Negocio>();
		}

        /// <summary>
        /// Autor: Luciano Azevedo
        /// MetodoResponsavel por Consultar a lista de Negocios de uma Ordem
        /// </summary>
        /// <param name="ordem"></param>
        /// <returns>colecao de negocios</returns>
        public List<BusinessEntity.Negocio> ConsultarNegociosOrdem(BusinessEntity.Ordem ordem)
        {
            ResourceAccess.Negocio negocio = new ResourceAccess.Negocio();
            List<BusinessEntity.Negocio> lstNegocio = negocio.ConsultarNegociosOrdem(ordem);
            if (lstNegocio != null && lstNegocio.Count > 0)
                return lstNegocio;
            else
                throw new BusinessException(ERRO_NEGOCIO_SEM_ORDEM);
        }


        /// <summary>
        /// Historico: ALT01
        /// Data : 10/01/2007
        /// Autor: Luciano Azevedo
        /// Obs.: Business Exceptions Alteradas
        /// </summary>
        /// <returns></returns>

        #region Validações

        private void ValidarNegocioDiasLiquidacao(BusinessEntity.Negocio request)
        {
            ResourceAccess.Negocio negocio = new ResourceAccess.Negocio();
            if (request.DiasLiquidacao.HasValue && !negocio.ConsultarDiasLiquidacao(request.DiasLiquidacao.Value))
                throw new BusinessException(ERRO_NEGOCIO_DIASLIQUIDACAOINVALIDOS);
        }

        private int ValidarEntradaContraParte(BusinessEntity.Negocio request)
        {
            if (request.ContraParte.HasValue && request.ContraParte.Value <= 0)
                return ERRO_NEGOCIO_CONTRAPARTEINVALIDA;
            else
                return 0;
        }

        private int ValidarEntradaBolsa(BusinessEntity.Negocio request)
        {
            if (string.IsNullOrEmpty(request.Bolsa))
                return ERRO_NEGOCIO_BOLSANAOINFORMADA;
            else
                return 0;
        }

        private void ValidarNegocioBolsa(BusinessEntity.Negocio request)
        {
            Bolsa bolsaBL = new Bolsa();
            bolsaBL.ValidarCodigo(request.Bolsa);
        }

        /// <summary>
        /// Data:08/02/2008 11:43
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Metodo responsavel por realizar as validacao de entrada do metodo de inclusao
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private void ValidarEntradaInclusaoAlteracao(BusinessEntity.Negocio request)
        {
            ValidationException ex = new ValidationException();
            int errorCode = 0;

            errorCode = ValidarEntradaBolsa(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            errorCode = ValidarEntradaDataPregao(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            errorCode = ValidarEntradaNumeroNegocio(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            errorCode = ValidarEntradaNaturezaOperacao(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            errorCode = ValidarEntradaMercado(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            errorCode = ValidarEntradaTitulo(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            errorCode = ValidarEntradaQuantidade(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            //20080424 11:18 - Removido para atender ao chamado 3584 - DMilanez.7Comm
            //errorCode = ValidarEntradaFatorValorizacao(request);
            //if (errorCode > 0)
            //    ex.AddError(errorCode);

            errorCode = ValidarEntradaPreco(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            errorCode = ValidarEntradaVencimentoOpcoesTermoFuturo(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            errorCode = ValidarEntradaContraParte(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            errorCode = ValidarEntradaTipoTermo(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            errorCode = ValidarEntradaTipoLiquidacao(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            if (ex.ValidationErrors != null && ex.ValidationErrors.Count > 0)
                throw ex;
        }

        /// <summary>
        /// Data:08/02/2008 11:43
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Metodo responsavel por realizar as validacao de negocio do metodo de inclusao
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private void ValidarNegocioInclusaoAlteracao(BusinessEntity.Negocio request, BusinessEntity.Enum.ModuloChamador modulo, TipoOperacao operacao)
        {
            ValidarEstadoSistema(modulo);//20080512 14:31 - RValadao - Issue 0004618 

            ValidarDataPregaoCalendario(request);//20080512 16:31 - RValadao - Issue 0004618 

            //20080424 11:19 - Adicionado para atender ao chamado 3584 - DMilanez.7Comm
            ValidarNegocioFatorValorizacao(request, operacao);

            ValidarNegocioBolsa(request);

            ValidarNegocioDataPregao(request, modulo);

            ValidarNegocioMercado(request);

            ValidarNegocioTitulo(request);

            ValidarNegocioQuantidade(request);

            ValidarNegocioQuantidade(request);

            ValidarNegocioVencimentoOpcoesTermoFuturo(request);

            ValidarNegocioPrazoTermo(request);

            ValidarNegocioDiasLiquidacao(request);

            ValidarNegocioCodigoCorrespondente(request);

            ValidarNegocioPercentualCorrespondente(request);

            ValidarNegocioTipoOfertaBovespaFix(request);

            ValidarNegocioEstrategia(request);
        }

        /// <summary>
        /// Data:08/02/2008 11:43
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Metodo responsavel por validar os dados de entrada do metodo de inclusao
        /// 
        /// Data : 11/02/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Revisao e complemento
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private void ValidarEntradaExclusao(BusinessEntity.Negocio request)
        {
            ValidationException ex = new ValidationException();
            int errorCode = 0;

            //db.AddInParameter(dbCommand, ":CD_BOLSAMOV", DbType.String, request.Bolsa);
            errorCode = ValidarEntradaBolsa(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            //db.AddInParameter(dbCommand, ":DT_PREGAO", DbType.DateTime, request.DataPregao.Value);
            errorCode = ValidarEntradaDataPregao(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            //db.AddInParameter(dbCommand, ":NR_NEGOCIO", DbType.Int32, request.NumeroNegocio.Value);
            errorCode = ValidarEntradaNumeroNegocio(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            //db.AddInParameter(dbCommand, ":CD_NATOPE", DbType.String, request.TipoNaturezaOperacao.Value);
            errorCode = ValidarEntradaNaturezaOperacao(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            //db.AddInParameter(dbCommand, ":CD_NEGOCIO", DbType.String, request.Titulo.Codigo);
            errorCode = ValidarEntradaTitulo(request);
            if (errorCode > 0)
                ex.AddError(errorCode);

            if (ex.ValidationErrors != null && ex.ValidationErrors.Count > 0)
                throw ex;
        }


        /// <summary>
        /// Data:08/02/2008 11:56
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Metodo responsavel por validar a entrada da data de pregao
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        /// 
        /// Data:13/04/2008 12:49
        /// Autor:DMilanez.7Comm
        /// Obs: Alterado de forma a atribuir a data de movimento a data
        /// de pregao caso a mesma n tiver sido informada
        private int ValidarEntradaDataPregao(BusinessEntity.Negocio request)
        {
            if (!request.DataPregao.HasValue)
            {
                //20080413 12:51 - Alterado - DMilanez.7Comm
                request.DataPregao = (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.DataMovimento()).RecuperarDataMovimento();
                if (!request.DataPregao.HasValue)
                    return ERRO_NEGOCIO_DATAPREGAONAOINFORMADA;
                else return 0;
            }
            else
                return 0;
        }

        /// Data:07/02/2008 17:15
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Correcao
        /// Alterado para validar de acordo com regras informadas pelo analista Sinacor
        /// 
        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        private void ValidarNegocioDataPregao(BusinessEntity.Negocio request, BusinessEntity.Enum.ModuloChamador modulo)
        {
            Sinacor.Servico.Bovespa.Calendario.ResourceAccess.Calendario calendarioRA = new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.Calendario();
            Sinacor.Servico.Bovespa.Calendario.BusinessEntity.Calendario calendarioBE = new Sinacor.Servico.Bovespa.Calendario.BusinessEntity.Calendario();

            calendarioBE.CodigoPraca = request.Bolsa;

            if (modulo == BusinessEntity.Enum.ModuloChamador.FaturamentoBolsas) //BOL
            {
                calendarioBE = calendarioRA.ConsultarControleDiasUteisFeriadosFaturamentoBolsas(calendarioBE);
            }
            else
            {
                calendarioBE = calendarioRA.ConsultarControleDiasUteisFeriadosControleOrdens(calendarioBE);
            }

            if (calendarioBE == null)
            {
                throw new BusinessException(ERRO_NEGOCIO_INFORMACOES_DIAS_UTEIS_FERIADOS_NAO_ENCONTRADAS);
            }
            else
            {
                if (calendarioBE.TipoDia != "U" || calendarioBE.DataPregao != request.DataPregao)
                {
                    calendarioBE.DataPregao = request.DataPregao.Value;
                    calendarioBE.CodigoPraca = request.Bolsa;

                    if (modulo == BusinessEntity.Enum.ModuloChamador.FaturamentoBolsas) //BOL
                        calendarioBE = calendarioRA.ConsultarDataMovimentoSistemaFaturamentoBolsas(calendarioBE);
                    else
                        calendarioBE = calendarioRA.ConsultarDataMovimentoSistemaControleOrdens(calendarioBE);

                    if (calendarioBE == null)
                    {
                        throw new BusinessException(ERRO_NEGOCIO_DATAPREGAOINVALIDA);
                    }
                }
            }
        }

        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        private int ValidarEntradaNumeroNegocio(BusinessEntity.Negocio request)
        {
            if (!request.NumeroNegocio.HasValue)
                return ERRO_NEGOCIO_NUMERONAOINFORMADO;
            else
                return 0;
        }

        /// <summary>
        /// Data: 17/01/2008
        /// Autor: Diogo Milanez
        /// Obs: Alterado de forma a considerar a bolsa ao validar a
        /// obrigatoriedade do digito do negocio
        /// </summary>
        /// <param name="digito"></param>
        /// <param name="codigoBolsa"></param>
        /// <returns></returns>
        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        private int ValidarEntradaDigitoNegocio(Int32? digito, string codigoBolsa)
        {
            if (codigoBolsa != "1" && !digito.HasValue)
                return ERRO_NEGOCIO_DIGITONAOINFORMADO;
            else
                return 0;
        }

        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        private int ValidarEntradaNaturezaOperacao(BusinessEntity.Negocio request)
        {
            if (!request.TipoNaturezaOperacao.HasValue)
                return ERRO_NEGOCIO_NATUREZAOPERACAONAOINFORMADA;
            else
                return 0;
        }

        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        private int ValidarEntradaMercado(BusinessEntity.Negocio request)
        {
            if (!request.TipoMercado.HasValue)
                return ERRO_NEGOCIO_MERCADONAOINFORMADO;
            else
                return 0;
        }

        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        private void ValidarNegocioMercado(BusinessEntity.Negocio request)
        {
            Mercado mercadoBL = new Mercado();
            BusinessEntity.Mercado mercadoBE = new BusinessEntity.Mercado();
            mercadoBE.TipoMercado = request.TipoMercado;
            mercadoBL.ValidarMercado(mercadoBE);
        }

        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        private int ValidarEntradaQuantidade(BusinessEntity.Negocio request)
        {
            if (!request.Quantidade.HasValue)
                return ERRO_NEGOCIO_QUANTIDADENAOINFORMADA;
            else if (request.Quantidade <= 0)
                return ERRO_NEGOCIO_QUANTIDADEINVALIDA;
            else
                return 0;
        }

        /// Data:24/04/2008 11:27
        /// Autor:DMilanez.7Comm
        /// Obs: Metodo responsavel por validar o Fator de Valorizacao
        private void ValidarNegocioFatorValorizacao(BusinessEntity.Negocio request, TipoOperacao operacao)
        {
            //se for uma alteracao
            if (operacao == TipoOperacao.Alteracao)
            {
                //e n informado , deverá obrigar a entrada do valor
                if (!request.FatorValorizacao.HasValue || request.FatorValorizacao <= 0)
                {
                    throw new BusinessException(ERRO_NEGOCIO_FATORVALORIZACAOINVALIDO);
                }
            }
            //se inclusao
            else if (operacao == TipoOperacao.Inclusao)
            {
                //e n informado, assumir o do cadastro de papel
                if (!request.FatorValorizacao.HasValue || request.FatorValorizacao <= 0)
                    request.FatorValorizacao = request.Titulo.FatorCotacao;
            }
        }

        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado        
        /// 
        /// Data:11/02/2008 10:59
        /// Autor:DMilanez.7Comm
        /// Obs: Parametros de entrada alterados
        private void ValidarNegocioQuantidade(BusinessEntity.Negocio request)
        {
            //20080423 19:02 - Alterado para atender ao chamado 3349 - DMilanez.7Comm
            if (request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra ||
                 request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda ||
                 request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Futuro ||
                 request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.VencimentoFuturo
                 )
            {
                Titulo.BusinessLogic.Titulo tituloBL = new Sinacor.Servico.Bovespa.Titulo.BusinessLogic.Titulo();
                int? loteminimo = tituloBL.ConsultarQuantidadeMinimaLoteNegociacao(request.Titulo);

                //20080423 19:02 - Alterado para atender ao chamado 3349 - DMilanez.7Comm
                if (loteminimo > 0)
                {
                    //20080423 19:02 - Alterado para atender ao chamado 3349 - DMilanez.7Comm
                    //if (!((request.Quantidade % loteminimo == 0) && (request.Quantidade >= loteminimo)))//20080412 16:19 - Alterado - DMilanez.7Comm
                    if ((request.Quantidade % loteminimo != 0) || (request.Quantidade < loteminimo))
                        throw new BusinessException(ERRO_NEGOCIO_QUANTIDADEINVALIDA);
                }
            }
        }

        /// <summary>
        /// Data:11/02/2008 16:36
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// </summary>
        /// <param name="request"></param>
        private void ValidarNegocioPercentualCorrespondente(BusinessEntity.Negocio request)
        {//aqui
            Sinacor.Servico.Bovespa.Cliente.BusinessLogic.Correspondente correspondenteBL = new Sinacor.Servico.Bovespa.Cliente.BusinessLogic.Correspondente();

            if (request.Correspondente.Codigo == 0)
            {
                request.Correspondente.PercentualComissao = 0;
            }
            else
            {
                if (!request.Correspondente.PercentualComissao.HasValue)
                {
                    //Assumir TBOCORRESP.PC_COMISSAO retornado na query de validação do código do correspondente
                    request.Correspondente.PercentualComissao = correspondenteBL.RecuperarPercentualComissao(request.Correspondente.Codigo.Value);
                }
                else
                {
                    //Valor informado deve estar entre zero e 100
                    if (request.Correspondente.PercentualComissao < 0 || request.Correspondente.PercentualComissao > 100)
                        throw new BusinessException(ERRO_NEGOCIO_PERCENTUAL_CORRESPONDENTE_INVALIDO);
                }
            }


            //Se Codigo do Correspondente = 0
            //   Assumir zero
            //Caso contrário
            //   Se percentual não informado
            //      Assumir TBOCORRESP.PC_COMISSAO retornado na query de validação do código do correspondente
            //   Caso contrário
            //      Valor informado deve estar entre zero e 100
        }

        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        private int ValidarEntradaPreco(BusinessEntity.Negocio request)
        {
            if (request.Preco <= 0)
                return ERRO_NEGOCIO_PRECOINVALIDO;
            else
                return 0;
        }

        /// <summary>
        /// Data:08/02/2008 15:04
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private int ValidarEntradaVencimentoOpcoesTermoFuturo(BusinessEntity.Negocio request)
        {
            if ((request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra ||
                 request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda ||
                 request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.VencimentoFuturo ||
                 request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Futuro) &&
                 !request.VencimentoOpcoesTermo.HasValue)
                return ERRO_NEGOCIO_VENCIMENTOOPCOESTERMOFUTURO_NAOINFORMADO;
            else
                return 0;

        }

        //private void ValidarNegocioVencimentoOpcoesTermoFuturo(DateTime? vencimentoOpcoesTermo, Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado? tipoMercado, String codigoTitulo)
        /// <summary>
        /// Metodo responsavel por validar a Informacao VencimentoOpcoes/Termo/Turmo
        /// **
        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        /// **
        /// Data:11/02/2008 11:18
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Correcoes diversas nas validacoes
        /// </summary>
        /// <param name="request"></param>
        /// 20080413 13:08 - Alterado para atender ao chamado 0003077 - DMilanez.7Comm
        /// Regra: Caso o mercado seja termo, e n tenha sido informado o PrazoTermo e o VencimentoOpcoesTermo
        /// informar que o prazo do VencimentoOpcoesTermo n foi informado
        private void ValidarNegocioVencimentoOpcoesTermoFuturo(BusinessEntity.Negocio request)
        {
            //20080423 17:42 - Alterado para atender ao chamado 3325 - DMilanez.7Comm
            Regex r = new Regex(@"[0-9]+");
            string value = r.Match(request.Titulo.Codigo).Value;

            if (request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra || request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda ||
                request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.VencimentoFuturo || request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Futuro
                )
            {
                if (!request.VencimentoOpcoesTermo.HasValue)
                    throw new BusinessException(ERRO_NEGOCIO_VENCIMENTOTERMO_NAOINFORMADO);
            }
            else if (request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Termo)
            {
                //20080423 17:42 - Alterado para atender ao chamado 3325 - DMilanez.7Comm
                if (!string.IsNullOrEmpty(value))
                {
                    if (Convert.ToInt32(value) >= 50)
                    {
                        if (!request.VencimentoOpcoesTermo.HasValue)
                            throw new BusinessException(ERRO_NEGOCIO_VENCIMENTOTERMO_NAOINFORMADO);
                    }
                    else
                    {
                        if (!request.PrazoTermo.HasValue)
                            throw new BusinessException(ERRO_NEGOCIO_PRAZOTERMO_NAOINFORMADO);
                    }
                }
            }
            else
            {
                request.VencimentoOpcoesTermo = null;
            }
        }

        /// <summary>
        /// Data: 17/01/2008
        /// Autor: Diogo Milanez
        /// Obs: Alterado de forma a validar o Prazo do Termo apenas quando o mercado
        /// for termo
        /// **
        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        /// **
        /// Data:11/02/2008 11:10
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Correcoes diversas
        /// </summary>
        /// <param name="prazoTermo"></param>
        /// <param name="tipoMercado"></param>
        /// <param name="codigoTitulo"></param>
        /// <returns></returns>
        /// 20080413 13:08 - Alterado para atender ao chamado 0003077 - DMilanez.7Comm
        /// Regra: Caso o mercado seja termo, e n tenha sido informado o PrazoTermo e o VencimentoOpcoesTermo
        /// informar que o prazo do termo n foi informado
        private void ValidarNegocioPrazoTermo(BusinessEntity.Negocio request)
        {
            Regex r = new Regex(@"\d");
            string value = r.Match(request.Titulo.Codigo).Value;

            if (request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Termo)
            {
                if (!string.IsNullOrEmpty(value) && Convert.ToInt32(value) >= 50)
                {
                    request.PrazoTermo = null;
                }
                else
                {
                    //20080413 13:06 - Alterado para atender ao chama do 0003077- DMilanez.7Comm
                    if ((!request.PrazoTermo.HasValue || request.PrazoTermo < 0) && !request.VencimentoOpcoesTermo.HasValue)
                        throw new BusinessException(ERRO_NEGOCIO_PRAZOTERMO_NAOINFORMADO);
                }
            }
            else
            {
                request.PrazoTermo = null;
            }

        }

        /// <summary>
        /// Data: 17/01/2008
        /// Autor: Diogo Milanez
        /// Obs: Alterado de forma a corrigir a validacao
        /// Regra -> Facultativo, somente obrigatorio para mercado termo
        /// </summary>
        /// <param name="tipoTermo"></param>
        /// <param name="tipoMercado"></param>
        /// <returns></returns>
        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        //private void ValidarEntradaTipoTermo(Comum.Enums.TipoTermo? tipoTermo, Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado? tipoMercado)
        private int ValidarEntradaTipoTermo(BusinessEntity.Negocio request)
        {
            if (request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Termo &&
                (request.TipoTermo != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoTermo.VontadeComprador &&
                 request.TipoTermo != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoTermo.VontadeVendedor &&
                 request.TipoTermo != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoTermo.AcordoMutuo
                )
               )
                return ERRO_NEGOCIO_TIPOTERMOINVALIDO;
            else
                return 0;
        }

        /// <summary>
        /// Data: 17/01/2008
        /// Autor: Diogo Milanez
        /// Obs: Alterado de forma a validar a obrigatoriedade do tipo de liquidacao
        /// apenas quando a bolsa informada for diferente de 1 , 5 e 8
        /// </summary>
        /// <param name="tipoLiquidacaoNegocio"></param>
        /// <param name="bolsa"></param>
        /// <returns></returns>
        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        private int ValidarEntradaTipoLiquidacao(BusinessEntity.Negocio request)
        {
            //20080413 13:02 - Alterado para atender ao chamado 0003077 - DMilanez.7Comm
            if (request.Bolsa != "3" && request.Bolsa != "7" && !request.TipoLiquidacaoNegocio.HasValue)
            {
                request.TipoLiquidacaoNegocio = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacaoNegocio.LiquidacaoPeloLiquido;
            }
            else if (request.Bolsa != "1" && request.Bolsa != "5" && request.Bolsa != "8")
            {
                if (!request.TipoLiquidacaoNegocio.HasValue)
                    return ERRO_NEGOCIO_TIPOLIQUIDACAONAOINFORMADO;
            }

            return 0;
        }

        /// <summary>
        /// Data:08/02/2008 14:35
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// </summary>
        /// <param name="titulo"></param>
        /// <returns></returns>
        private int ValidarEntradaTitulo(BusinessEntity.Negocio request)
        {
            if (request.Titulo == null || string.IsNullOrEmpty(request.Titulo.Codigo))
                return ERRO_NEGOCIO_TITULONAOINFORMADO;
            else
                return 0;
        }

        /// <summary>
        /// Metodo responsavel por realizar a validacao do titulo do negocio
        /// Data:08/02/2008 12:01
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        /// 
        /// Data:11/02/2008 10:30
        /// Autor:DMilanez.7Comm
        /// Obs:
        // Correcao na forma de validar
        /// </summary>
        /// <param name="request"></param>
        private void ValidarNegocioTitulo(BusinessEntity.Negocio request)
        {
            if (request.Titulo == null)
            {
                request.Titulo = new Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Titulo();
                Titulo.ResourceAccess.Titulo tituloRA = new Sinacor.Servico.Bovespa.Titulo.ResourceAccess.Titulo();

                request.Titulo.TipoMercado = (Titulo.BusinessEntity.Enum.TipoMercado)request.TipoMercado;
                request.Titulo.DataPregao = request.DataPregao;
                request.Titulo = tituloRA.ConsultarTituloCodigoMercadoDataPregao(request.Titulo, true);
                if (request.Titulo == null)
                    throw new BusinessException(ERRO_NEGOCIO_TITULO_NAO_CADASTRADO);

            }
        }

        /// Metodo responsavel por carregar os dados do titulo objeto e realizar validacoes
        /// de negocio relacionadas a essas informacoes
        /// Data:07/02/2008 15:25
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Parametros de entrada alterados de forma a utilizar uma BE
        /// Recodificado
        /// 
        /// Data:12/02/2008 15:14
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Retorno passou a ser void
        private void CarregarTituloObjeto(BusinessEntity.Negocio request)
        {
            //se n for informado o titulo objeto
            if (string.IsNullOrEmpty(request.TituloObjeto))
                return;

            Titulo.BusinessEntity.Titulo tituloBE = new Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Titulo();
            Titulo.ResourceAccess.Titulo tituloRA = new Sinacor.Servico.Bovespa.Titulo.ResourceAccess.Titulo();
            string codigoIsin;

            if (request.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra) ||
                 request.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoCompra) ||
                 request.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoVenda))
            {
                tituloBE.Codigo = request.Titulo.Codigo;
                tituloBE.TipoMercado = request.Titulo.TipoMercado;
                tituloBE.DataPregao = request.Titulo.DataPregao;
                tituloBE = tituloRA.ConsultarTituloCodigoMercadoDataPregao(tituloBE, false);

                if (tituloBE == null)
                {
                    throw new BusinessException(ERRO_NEGOCIO_TITULO_NAO_CADASTRADO);
                }
                else
                {
                    if (tituloBE.NomeSA == "IBOVESPA")
                    {
                        request.TituloObjeto = null;
                    }
                    else
                    {
                        codigoIsin = tituloBE.CodigoISIN;

                        tituloBE.Codigo = request.TituloObjeto;
                        tituloBE.TipoMercado = (Titulo.BusinessEntity.Enum.TipoMercado)Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista;
                        tituloBE.DataPregao = request.Titulo.DataPregao;
                        tituloBE = tituloRA.ConsultarTituloCodigoMercadoDataPregao(tituloBE, false);

                        if (tituloBE == null)
                        {
                            throw new BusinessException(ERRO_NEGOCIO_TITULO_OBJETO_NAO_CADASTRADO);
                        }
                        else
                        {
                            if (codigoIsin != tituloBE.CodigoISIN)
                            {
                                throw new BusinessException(ERRO_NEGOCIO_CODIGOSISIN_DIVERGENTES);
                            }
                        }
                    }
                }
            }
            else
                request.TituloObjeto = null;

        }

        /// Data:12/02/2008 13:30
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Correcoes diversas
        //private void ValidarNegocioEstrategia(string bolsa, Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado? tipoMercado, Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia? tipoEstrategia, Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOfertaBovespaFix? tipoOfertaBovespaFix)
        private void ValidarNegocioEstrategia(BusinessEntity.Negocio request)
        {
            //20080419 17:45 - Removido para atender ao chamado 3326 - DMilanez.7Comm
            ////20080413 12:55 - Alterado para atender ao chamado 0003077 - DMilanez.7Comm
            //if (request.Bolsa != "3" && request.Bolsa != "7" && !request.TipoEstrategia.HasValue)
            //{
            //    request.TipoEstrategia = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.Nenhuma;
            //}
            //else 
            if (request.Bolsa == "1" || request.Bolsa == "5" || request.Bolsa == "8")
            {
                if (!request.TipoEstrategia.HasValue)
                {
                    if (!string.IsNullOrEmpty(request.Titulo.CodigoISIN) && request.Titulo.CodigoISIN.Substring(6, 2) == "PP")
                    {
                        request.TipoEstrategia = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.POP;
                    }
                    else
                    {
                        request.TipoEstrategia = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.Nenhuma;
                    }
                }
                else
                {
                    if (request.TipoEstrategia == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.Nenhuma)
                        return;//ok
                    else if (request.TipoEstrategia == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.BOX)
                    {
                        if (request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra &&
                            request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda)
                        {
                            throw new BusinessException(ERRO_NEGOCIO_ESTRATEGIAINVALIDA);
                        }
                    }
                    else if (request.TipoEstrategia == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.DBX)
                    {
                        if (request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra &&
                            request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda &&
                            request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoCompra &&
                            request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoVenda)
                        {
                            throw new BusinessException(ERRO_NEGOCIO_ESTRATEGIAINVALIDA);
                        }
                    }
                    else if (request.TipoEstrategia == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.POP)
                    {
                        if (request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra &&
                            request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda &&
                            request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista)
                        {
                            throw new BusinessException(ERRO_NEGOCIO_ESTRATEGIAINVALIDA);
                        }
                    }

                    else if (request.TipoEstrategia == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.BTF)
                    {
                        if (request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Fracionario
                            && request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista)
                        {
                            throw new BusinessException(ERRO_NEGOCIO_ESTRATEGIAINVALIDA);
                        }
                    }
                                                           
                     else if (request.TipoEstrategia == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.TVR)
                    {
                        if (request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Fracionario
                            && request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista)
                        {
                            throw new BusinessException(ERRO_NEGOCIO_ESTRATEGIAINVALIDA);
                        }
                    }
                }
            }
                

            else if ((request.Bolsa == "2" || request.Bolsa == "6")
                      && request.TipoEstrategia == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.BTF)
            {
                if (request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Fracionario
                    && request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista)
                {
                    throw new BusinessException(ERRO_NEGOCIO_ESTRATEGIAINVALIDA);
                }
            }
                
                else if ((request.Bolsa == "2" || request.Bolsa == "6")
                      && request.TipoEstrategia == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoEstrategia.TVR)
            {
                if (request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Fracionario
                    && request.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista)
                {
                    throw new BusinessException(ERRO_NEGOCIO_ESTRATEGIAINVALIDA);
                }
            }
            else
            {
                request.TipoEstrategia = null;
            }
        }

        /// <summary>
        /// Data: 17/01/2008
        /// Autor: Diogo Milanez
        /// Obs: Criacao de metodo para validar obrigatoriedade Tipo de Oferta Bovespa Fix
        /// 
        /// </summary>
        /// <param name="bolsa"></param>
        /// <param name="tipoOfertaBovespaFix"></param>
        /// <returns></returns>
        /// Data:08/02/2008 12:06
        /// Autor:DMilanez.7Comm
        /// Obs: Renomeado
        //private void ValidarNegocioTipoOfertaBovespaFix(string bolsa, Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOfertaBovespaFix? tipoOfertaBovespaFix)
        private void ValidarNegocioTipoOfertaBovespaFix(BusinessEntity.Negocio request)
        {
            if ((request.Bolsa == "7" || request.Bolsa == "3"))
            {
                if (!request.TipoOfertaBovespaFix.HasValue)
                {
                    throw new BusinessException(ERRO_NEGOCIO_TIPOOFERTABOVESPAFIX_NAOINFORMADO);
                }
                else
                {
                    if (request.TipoOfertaBovespaFix != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOfertaBovespaFix.AgressorLancador &&
                        request.TipoOfertaBovespaFix != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOfertaBovespaFix.Tomador &&
                        request.TipoOfertaBovespaFix != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOfertaBovespaFix.Direto &&
                        request.TipoOfertaBovespaFix != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOfertaBovespaFix.Balcao
                        )
                    {
                        throw new BusinessException(ERRO_NEGOCIO_TIPOOFERTABOVESPAFIX_INVALIDO);
                    }
                }
            }
            else
            {
                request.TipoOfertaBovespaFix = null;
            }
        }

        /// Data:12/02/2008 15:14
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Retorno passou a ser void
        private void ValidarNegocioCodigoCorrespondente(BusinessEntity.Negocio request)
        {
            Sinacor.Servico.Bovespa.Cliente.BusinessLogic.Correspondente correspondenteBL = new Sinacor.Servico.Bovespa.Cliente.BusinessLogic.Correspondente();
            Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro param = new Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro();
            int agente = param.RecuperarAgenteCompensacao();

            //20080425 14:46 - Removido para atender ao chamado 3647 - DMilanez.7Comm
            ////Caso n informe o correpondente, atribuir zero ao codigo
            //if (request.Correspondente == null)
            //{
            //    request.Correspondente = new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Correspondente();
            //    request.Correspondente.Codigo = 0;
            //}
            //else if (!request.Correspondente.Codigo.HasValue)
            //{
            //    request.Correspondente.Codigo = 0;
            //}
            //else

            //20080425 14:46 - Alterado para atender ao chamado 3647 - DMilanez.7Comm
            if (request.Correspondente == null)
            {
                request.Correspondente = new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Correspondente();
            }

            //20080425 14:46 - Alterado para atender ao chamado 3647 - DMilanez.7Comm
            //se sitema BOL instalado
            if ((new Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso()).VerificarSistemaInstalado("BOL"))
            {
                if (correspondenteBL.VerificarExigenciaDigitacao(request.Bolsa, Sinacor.Infra.Service.Security.Authorization.AuthorizationContext.Current.UserId))
                {
                    //se n informar o correspondente, ou informar 0 ou valor negativo
                    if (!request.Correspondente.Codigo.HasValue || request.Correspondente.Codigo <= 0)//20080425 14:53 - Alterado para atender ao chamado 3647 - DMilanez.7Comm
                    {
                        throw new BusinessException(ERRO_NEGOCIO_CORRESPONDENTEINVALIDO);
                    }
                    else
                    {
                        //verificar se esta cadastrado
                        if (!correspondenteBL.VerificarExistencia(request.Correspondente.Codigo.Value))
                            throw new BusinessException(ERRO_NEGOCIO_CORRESPONDENTEINVALIDO);
                    }
                }
                else
                {
                    //se exige digitacao
                    if (correspondenteBL.VerificarSePodeExistirDigitacaoCorrespondente())
                    {
                        //se n informar o correspondente
                        if (!request.Correspondente.Codigo.HasValue)
                        {
                            throw new BusinessException(ERRO_NEGOCIO_CORRESPONDENTEINVALIDO);
                        }
                        else if (request.Correspondente.Codigo == 0)
                        {
                            //se existir agente de compensacao
                            if (param.RecuperarInAgenteCompensacao() == "S")
                            {
                                //recuperar codigo do agente de compensacao
                                request.Correspondente.Codigo = param.RecuperarCdAgenteCompensacao();
                                //verificar se esta cadastrado
                                if (!correspondenteBL.VerificarExistencia(request.Correspondente.Codigo.Value))
                                    throw new BusinessException(ERRO_NEGOCIO_CORRESPONDENTEINVALIDO);
                            }
                            else
                            {
                                request.Correspondente.Codigo = 0;
                            }
                        }
                        else
                        {
                            //verificar se esta cadastrado
                            if (!correspondenteBL.VerificarExistencia(request.Correspondente.Codigo.Value))
                                throw new BusinessException(ERRO_NEGOCIO_CORRESPONDENTEINVALIDO);
                        }
                    }
                    else
                    {
                        //20080413 15:27 - Alterado - DMilanez.7Comm
                        if (!request.Correspondente.Codigo.HasValue)
                        {
                            if (param.RecuperarInAgenteCompensacao() == "S")
                            {
                                //recuperar codigo do agente de compensacao
                                request.Correspondente.Codigo = param.RecuperarCdAgenteCompensacao();
                                //verificar se esta cadastrado
                                if (!correspondenteBL.VerificarExistencia(request.Correspondente.Codigo.Value))
                                    throw new BusinessException(ERRO_NEGOCIO_CORRESPONDENTEINVALIDO);
                            }
                            //20080425 14:50 - Alterado para atender o chamado 3647 - DMilanez.7Comm
                            else
                            {
                                request.Correspondente.Codigo = 0;
                            }
                        }
                        else
                        {
                            if (request.Correspondente.Codigo != 0)//20080425 15:36 - Alterado - DMilanez.7Comm
                                if (!correspondenteBL.VerificarExistencia(request.Correspondente.Codigo.Value))
                                    throw new BusinessException(ERRO_NEGOCIO_CORRESPONDENTEINVALIDO);
                        }
                    }
                }
            }
        }


        /// <summary>
        /// Metodo responsavel por consultar a lista de negocios para casar
        /// </summary>
        /// <param name="request">objeto utilizado para filtrar os dados</param>
        /// <returns>colecao de negocios para casar</returns>
        /// Historico:
        /// Data:	28/11/2007
        /// Autor:	Ludmilla Modesto
        /// Observacao: Alterado os parametros do metodo do RA
        /// 
        /// Data : 30/01/2008
        /// Autor: Eduardo Sertorio
        /// Observacao: Ajuste na verificacao do atributo TipoOrdem da Ordem devido alteracao no tipo de int para List de Enum TipoOrdem.
        /// </summary>
        /// <param name="desprezar"></param>
        public List<BusinessEntity.Negocio> ConsultarListaNegocioParaCasar(BusinessEntity.Negocio request)
        {
            List<BusinessEntity.Negocio> responseColletion = null;
            BusinessLogic.Ordem ordemBL = new BusinessLogic.Ordem();
            ResourceAccess.Ordem ordemRA = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Ordem();

            request.Ordem = ordemBL.ConsultarOrdem(request.Ordem);

            Decimal? precoLimite = ordemBL.ConsultarPrecoLimite(request.Ordem);
            //request.Ordem.TipoOrdem = ordemRA.ConsultarTipoOrdem(request.Ordem);
            Boolean existeCasamento = ordemBL.VerificarExistenciaCasamento(request.Ordem);
            //Boolean isOrdemLimitada = Convert.ToString(request.Ordem.TipoOrdem).Contains("5"); //excluido - eduardo - 20080130
            Boolean isOrdemLimitada = request.Ordem.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Limitada); //incluido - eduardo - 20080130

            ResourceAccess.Negocio raNegocio = new ResourceAccess.Negocio();
            responseColletion = raNegocio.ConsultarNegocioParaCasar(request, precoLimite, isOrdemLimitada, existeCasamento);

            return responseColletion;
        }

        /// Data:12/05/2008 14:30
        /// Autor:Rvaladao
        /// Obs: Validar o estado do sistema
        /// Issue 4618
        public void ValidarEstadoSistema(BusinessEntity.Enum.ModuloChamador modulo)
        {
            string strTipoMovimento = string.Empty;
            int iCodErro = 0;
            Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro param = new Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro();

            if (modulo == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.ModuloChamador.FaturamentoBolsas)
            {
                if ((new Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso()).VerificarSistemaInstalado("ORD"))
                {
                    strTipoMovimento = (new Bovespa.Ordens.ResourceAccess.MovimentoControleOrdens()).ConsultarTipoMovimento();
                    iCodErro = ERRO_NEGOCIO_CONTROLE_ORDENS_FECHADO;
                }
                else
                {
                    strTipoMovimento = param.ConsultarTipoMovimento();
                    iCodErro = ERRO_NEGOCIO_FATURAMENTO_BOLSAS_FECHADO;
                }
            }
            else //se for ModuloChamador.ControleOrdens
            {
                strTipoMovimento = (new Bovespa.Ordens.ResourceAccess.MovimentoControleOrdens()).ConsultarTipoMovimento();
                iCodErro = ERRO_NEGOCIO_CONTROLE_ORDENS_FECHADO;
            }

            if (!strTipoMovimento.Equals("A"))
            {
                throw new BusinessException(iCodErro);
            }
        }

        
        /// Data:12/05/2008 14:30
        /// Autor:Rvaladao
        /// Obs: Validar se a data do pregão está dentro da data do calendário
        /// Issue 4618
        private void ValidarDataPregaoCalendario(BusinessEntity.Negocio request)
        {
            if (!((new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.Calendario()).ValidarDataPregaoPreBoletoCalendario(request.DataPregao.Value)))
            {
                throw new BusinessException(ERRO_DATAPREGAOINVALIDA); //"Data do pregão inválida."
            }
        }
        #endregion

        /// Data:12/02/2008 15:28
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Metodo responsavel por realizar a inclusao de um comitente apos a inclusao/alteracao de um negocio
        private void IncluirComitente(BusinessEntity.Negocio requestNegocio)
        {
            ResumoFinanceiro.BusinessEntity.Comitente requestComitente = new Sinacor.Servico.Bovespa.ResumoFinanceiro.BusinessEntity.Comitente();
            ResumoFinanceiro.ResourceAccess.ResumoFinanceiro resumoFinanceiroRa = new Sinacor.Servico.Bovespa.ResumoFinanceiro.ResourceAccess.ResumoFinanceiro();
            ResumoFinanceiro.ResourceAccess.Comitente comitenteRA = new Sinacor.Servico.Bovespa.ResumoFinanceiro.ResourceAccess.Comitente();

            Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Cliente clienteBE = new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Cliente();
            clienteBE.Codigo = requestNegocio.Correspondente.Codigo;
            clienteBE = (new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente()).ConsultarDadosCorrespondente(clienteBE);

            if (clienteBE == null)
                throw new BusinessException(ERRO_NEGOCIO_CORRESPONDENTE_NAOENCONTRADO);

            requestComitente.Negocio.Ordem.DataOrdem = null;
            requestComitente.Negocio.Ordem.NumeroOrdem = 0;
            requestComitente.Negocio.Ordem.NumeroOrdemSubSequencia = 0;
            requestComitente.DataMovimento = requestNegocio.DataMovimento;
            requestComitente.DataNegocio = requestNegocio.DataPregao;
            requestComitente.Negocio.Bolsa = requestNegocio.Bolsa;
            requestComitente.Negocio.NumeroNegocio = requestNegocio.NumeroNegocio;
            requestComitente.Negocio.DigitoNegocio = requestNegocio.DigitoNegocio;
            requestComitente.Negocio.TipoNaturezaOperacao = requestNegocio.TipoNaturezaOperacao;
            requestComitente.CodigoCliente = requestNegocio.Correspondente.Codigo;
            requestComitente.DigitoCliente = clienteBE.Digito;
            requestComitente.CodigoClienteBroker = clienteBE.CodigoClienteBroker;
            requestComitente.DigitoClienteBroker = clienteBE.DigitoClienteBroker;
            requestComitente.CodigoClienteLiquidacaoFinanceira = clienteBE.CodigoClienteLiquidacaoFinanceira;
            requestComitente.DigitoClienteLiquidacaoFinanceira = clienteBE.DigitoClienteLiquidacaoFinanceira;
            requestComitente.QuantidadeEspecificadaCliente = requestNegocio.Quantidade;
            requestComitente.CodigoCarteiraLiquidacao = 0;

            requestComitente.PorcentagemReducaoAcrescimoCorretagem = requestNegocio.Correspondente.PercentualComissao;
            if (clienteBE.PercentualTotal == 0)
                requestComitente.PorcentagemReducaoAcrescimoCorretagem *= -1;

            requestComitente.CodigoUsuarioFinal = 0;
            requestComitente.CodigoClienteFinal = "0";
            requestComitente.DigitoClienteFinal = 0;
            requestComitente.IndicadorOrigem = "Sinacor.Servico.Bovespa.Ordens";
            requestComitente.NumeroPreboleto = 0;
            requestComitente.IndicadorCorrespondente = "S";
            requestComitente.CodigoNegocio = requestNegocio.Titulo.Codigo;
            requestComitente.CodigoCorrespondente = 0;
            requestComitente.ValorDolar = 1;
            requestComitente.TipoLiquidacao = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Normal;
            requestComitente.NumeroSeqOpe = 0;
            requestComitente.IndicadorHomeBroker = "N";
            requestComitente.NumeroComitente = 0;
            requestComitente.NomeUsuario = AuthorizationContext.Current.ClientHost.Name;
            requestComitente.DataSistema = (new Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro()).RecuperarDataSistemaBancoDados();
            requestComitente.TipoNegocio = (new ResourceAccess.Negocio()).ExecutarBuscaTipoGrav(requestNegocio);

            comitenteRA.IncluirComitente(requestComitente);

            //realizar calculo
            CalcularFinanceiroCorrespondente(requestNegocio);
        }

        /// <summary>
        /// Data: 06/08/2008
        /// Autor: WAbreu.7COMm
        /// Criação do método
        /// </summary>
        /// <param name="pConsultarNegocioOrdemDigitacao"></param>
        /// <returns></returns>
        public List<BusinessEntity.Negocio> ConsultarNegocioOrdemDigitacao(BusinessEntity.Parameter.ConsultarNegocioOrdemDigitacaoRequest pConsultarNegocioOrdemDigitacao)
        {            
            List <BusinessEntity.Negocio> negocios = (new ResourceAccess.Negocio()).ConsultarNegocioOrdemDigitacao(pConsultarNegocioOrdemDigitacao);

            if (negocios == null || negocios.Count == 0)
                throw new BusinessException(ERRO_PESQUISA_SEM_RESULTADO);
            else
                return negocios;
        }

        /// <summary>
        /// Data: 12/08/2008
        /// Autor: WAbreu.7COMm
        /// Criação do método
        /// </summary>
        /// <param name="pConsultarNegocioOrdemDigitacao"></param>
        /// <returns></returns>
        public List<BusinessEntity.Negocio> ConsultarNegocioLoteDigitacao(BusinessEntity.Parameter.ConsultarNegocioLoteDigitacao pConsultarNegocioLoteDigitacao)
        {
            List<BusinessEntity.Negocio> negocios = (new ResourceAccess.Negocio()).ConsultarNegocioLoteDigitacao(pConsultarNegocioLoteDigitacao);
            return negocios;

            
            //if (negocios == null || negocios.Count == 0)
            //    throw new BusinessException(ERRO_PESQUISA_SEM_RESULTADO);
            //else
            //    return negocios;
        }

        /// <summary>
        /// Data: 29.11.2008
        /// Autor: MBelarmino
        /// Consultar ADR´s
        /// </summary>
        /// <param name="pConsultarADR"></param>
        /// <returns></returns>
        public BusinessEntity.ADR ConsultarADR(BusinessEntity.Parameter.ConsultarADR pConsultarADR)
        {
            ResourceAccess.Negocio raNegocio = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Negocio();
            return raNegocio.ConsultarADR(pConsultarADR);
        }

        public bool SistemaAberto()
        {
            ResourceAccess.MovimentoControleOrdens objRaMCO = new MovimentoControleOrdens();

            return objRaMCO.SistemaAberto();
        }
        
		public List<BusinessEntity.NegocioExecutado> ConsultarNegocioExecutado(BusinessEntity.Parameter.ConsultarNegocioExecutado pConsultarNegocioExecutado){
			ResourceAccess.Negocio objRaNegocio = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Negocio();
			return objRaNegocio.ConsultarNegocioExecutado(pConsultarNegocioExecutado);
		}


        public List<BusinessEntity.Negocio> ConsultarNegocioListaLoteDigitacao(List<BusinessEntity.Parameter.ConsultarNegocioLoteDigitacao> parm)
        {
            List<BusinessEntity.Negocio> negocios = (new ResourceAccess.Negocio()).ConsultarNegocioListaLoteDigitacao(parm);
            return negocios;
        }

        private void TratarExcecoes(BusinessEntity.Resultado request)
        {
            if (string.IsNullOrEmpty(request.Argumentos))
                throw new BusinessException(request.CodigoErro);
            else
            {
                List<Object> _params = ErrorMessage.ConvertXmlArgumentsToParameters(request.Argumentos);

                if (_params != null)
                    throw new BusinessException(request.CodigoErro, _params.ToArray());
                else
                    throw new BusinessException(request.CodigoErro);
            }
        }
    }
}
